﻿using System;
using Kaesoft.Hospedaje.Entities;
using Kaesoft.Hospedaje.Proxy;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.ComponentModel.DataAnnotations;

namespace Kaesoft.Hospedaje.Common
{
    public class VentanaClavesViewModel : ViewModelBase
    {
        #region Variables
        private Usuario _autenticado;
        private string _confirmaClave;
        private string _claveNueva;
        private RelayCommand _cambioDeClave;
        private string _mensaje;
        public event EventHandler PasswordChanged;
        public event EventHandler WindowClosing;
        private RelayCommand _cerrarVentana;

        public RelayCommand CerrarVentana
        {
            get
            {
                return _cerrarVentana ?? (_cerrarVentana = new RelayCommand(EjecutaCerrarVentana));
            }
        }

        private void EjecutaCerrarVentana(object param)
        {
            var window = (VentanaClavesView)param;
            if (window != null)
            {
                window.DialogResult = false;
                OnWindowClosing();
            }
        }
        
        #endregion

        #region Propiedades
        /// <summary>
        /// Mensaje que muestra las alertas dentro de la ventana de cambio de claves
        /// </summary>
        public string Mensaje
        {
            get { return _mensaje; }
            set
            {
                if (_mensaje != value)
                {
                    _mensaje = value;
                    OnPropertyChanged("Mensaje");
                }
            }
        }

        /// <summary>
        /// Comando que ejecuta el cambio de clave
        /// </summary>
        public RelayCommand CambioDeClave
        {
            get
            {
                return _cambioDeClave ?? (_cambioDeClave = new RelayCommand(EjecutaCambio));
            }
        }

        /// <summary>
        /// Propiedad que almacena el unsuario autenticado
        /// </summary>
        public Usuario Autenticado
        {
            get { return _autenticado; }
            set
            {
                if (_autenticado != value)
                {
                    _autenticado = value;
                    OnPropertyChanged("Autenticado");
                }
            }
        }

        /// <summary>
        /// clave nueva ingresada por parte del usuario 
        /// </summary>
        [RegularExpression(@"(?!^[0-9]*$)(?!^[a-zA-Z]*$)^([a-zA-Z0-9]{8,10})$", 
            ErrorMessage = "Debe ingresar minimo 8 caracteres y maximo 10 caracteres alfanumericos.")]
        public string ClaveNueva
        {
            get { return _claveNueva; }
            set
            {
                if (_claveNueva != value)
                {
                    Validator.ValidateProperty(value, new ValidationContext(this, null, null) { MemberName = "ClaveNueva" });
                    _claveNueva = value;
                    OnPropertyChanged("ClaveNueva");
                }
            }
        }

        /// <summary>
        /// confirma la clave que se quiere cambiar
        /// </summary>
        [RegularExpression(@"(?!^[0-9]*$)(?!^[a-zA-Z]*$)^([a-zA-Z0-9]{8,10})$",
            ErrorMessage = "Debe ingresar minimo 8 caracteres y maximo 10 caracteres alfanumericos.")]
        public string ConfirmaClave
        {
            get { return _confirmaClave; }
            set
            {
                if (_confirmaClave != value)
                {
                    Validator.ValidateProperty(value, new ValidationContext(this, null, null) { MemberName = "ConfirmaClave" });
                    _confirmaClave = value;
                    OnPropertyChanged("ConfirmaClave");
                }
            }
        }
        #endregion

        #region Constructor
        /// <summary>
        /// Metodo constructor
        /// </summary>
        public VentanaClavesViewModel()
        {
        }
        #endregion

        #region Metodo Privados
        /// <summary>
        /// metodo completed de GrabarUsuarios
        /// </summary>
        /// <param name="param">se envia el objeto ventana</param>
        /// <param name="e">evento del completed</param>
        private void GrabarUsuariosCompleted(object param, AsyncCompletedEventArgs e)
        {
            if (e.Error == null)
            {
                WcfProxyInvoker.Clave = Autenticado.clave;
                WcfProxyInvoker.Usuario = Autenticado.usuario1;
                var window = (VentanaClavesView)param;
                if (window != null)
                {
                    window.DialogResult = true;
                    OnPasswordChanged();
                }
            }
            Procesando = false;
        }

        /// <summary>
        /// disparador del evento PasswordChanged
        /// </summary>
        private void OnPasswordChanged()
        {
            if (PasswordChanged != null)
                PasswordChanged(this, new EventArgs());
        }

        /// <summary>
        /// Disparador del evento CloseWindow
        /// </summary>
        private void OnWindowClosing()
        {
            if (WindowClosing != null)
                WindowClosing(this, new EventArgs());
        }

        /// <summary>
        /// Metodo ejecutado por el comando (CambioDeClave)
        /// </summary>
        /// <param name="param">se envia como parámetro el objeto ventana</param>
        private void EjecutaCambio(object param)
        {
            if (!string.IsNullOrEmpty(ClaveNueva) || !string.IsNullOrEmpty(ConfirmaClave))
            {
                if (ClaveNueva.ToString().Trim() == ConfirmaClave.ToString().Trim())
                {
                    Procesando = true;
                    Autenticado.clave = ClaveNueva;
                    Autenticado.cabiarClave = false;
                    Autenticado.idPerfil = Autenticado.UsuarioPerfils.Where(a => a.idUsuario == Autenticado.idUsuario).FirstOrDefault().idPerfil;
                    ProxyAdministracion.GrabarUsuariosAsync(new List<Usuario>() { Autenticado }, ev => GrabarUsuariosCompleted(param, ev));
                }
                else
                    Mensaje = "Confirmación de clave fallida.";
            }
            else
                Mensaje = "La clave nueva y su confirmación deben ser ingresadas";
        }
        #endregion
    }
}
